var decompressSTring = function (s) {
    let res = [];
    let ss = s.split('|')
    for (let i = 0; i < ss.length; i++) {
        let t = ss[i];
        if (t !== '') {
            let a = t.split('-')
            if (a.length === 2) {
                for (let j = 0; j < parseInt(a[1]); j++) {
                    res.push(parseInt(a[0]))
                }
            } else {
                res.push(parseInt(a[0]))
            }
        }
    }
    return res
}

WebGLBuffer = newFunc('WebGLBuffer', 1, function (){print('WebGLBuffer.call');mm.memory.private_data.set(this, {})});



; delete WebGLBuffer.prototype.constructor;
;
Object.defineProperties(WebGLBuffer.prototype, {
    [Symbol.toStringTag]:{
        value:'WebGLBuffer'
    },

'constructor': {

            value: newFunc('constructor', 10, function () {

                      if (!WebGLBuffer.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;
                    if (debug)print('WebGLBuffer.constructor.call', arguments)

            }), writable:true, enumerable:false, configurable:true,



        },
})
EXTTextureFilterAnisotropic = newFunc('EXTTextureFilterAnisotropic', 10, function WebGLBuffer() {

}, true);
Object.defineProperties(EXTTextureFilterAnisotropic.prototype, {
    MAX_TEXTURE_MAX_ANISOTROPY_EXT: {
        value: 34047, true: false, enumerable: true, writable: false
    },
    TEXTURE_MAX_ANISOTROPY_EXT: {
        value: 34046, true: false, enumerable: true, writable: false
    }
})

WebGLProgram = newFunc('WebGLProgram', 1, function (){print('WebGLProgram.call');mm.memory.private_data.set(this, {})});



; delete WebGLProgram.prototype.constructor;
;
Object.defineProperties(WebGLProgram.prototype, {
    [Symbol.toStringTag]:{
        value:'WebGLProgram'
    },

'constructor': {

            value: newFunc('constructor', 10, function () {

                      if (!WebGLProgram.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;
                    if (debug)print('WebGLProgram.constructor.call', arguments)

            }), writable:true, enumerable:false, configurable:true,



        },
})
WebGLShader = newFunc('WebGLShader', 1, function () {
    print('WebGLShader.call');
    mm.memory.private_data.set(this, {})
});


;delete WebGLShader.prototype.constructor;
;
Object.defineProperties(WebGLShader.prototype, {
    [Symbol.toStringTag]: {
        value: 'WebGLShader'
    },

    'constructor': {

        value: newFunc('constructor', 10, function () {

            if (!WebGLShader.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;
            if (debug) print('WebGLShader.constructor.call', arguments)

        }), writable: true, enumerable: false, configurable: true,


    },
})

WebGLShaderPrecisionFormat = newFunc('WebGLShaderPrecisionFormat', 10, function WebGLShaderPrecisionFormat(rangeMin, rangeMax, precision) {
    mm.memory.private_data.set(this, {
        rangeMin,
        rangeMax,
        precision
    })
}, true);


;delete WebGLShaderPrecisionFormat.prototype.constructor;
;
Object.defineProperties(WebGLShaderPrecisionFormat.prototype, {
    [Symbol.toStringTag]: {
        value: 'WebGLShaderPrecisionFormat'
    },

    'rangeMin': {

        get: newFunc('rangeMin', 10, function () {


            if (!WebGLShaderPrecisionFormat.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;

            let res = mm.memory.private_data.get(this)['rangeMin'];
            if (debug) print('WebGLShaderPrecisionFormat.rangeMin.get', res)

            return res
        }, {get: true}), enumerable: true, configurable: true,

    },
    'rangeMax': {

        get: newFunc('rangeMax', 10, function () {


            if (!WebGLShaderPrecisionFormat.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;

            let res = mm.memory.private_data.get(this)['rangeMax'];
            if (debug) print('WebGLShaderPrecisionFormat.rangeMax.get', res)

            return res
        }, {get: true}), enumerable: true, configurable: true,

    },
    'precision': {

        get: newFunc('precision', 10, function () {


            if (!WebGLShaderPrecisionFormat.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;

            let res = mm.memory.private_data.get(this)['precision'];
            if (debug) print('WebGLShaderPrecisionFormat.precision.get', res)

            return res
        }, {get: true}), enumerable: true, configurable: true,

    },
    'constructor': {

        value: newFunc('constructor', 10, function () {

            if (!WebGLShaderPrecisionFormat.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;
            if (debug) print('WebGLShaderPrecisionFormat.constructor.call', arguments)

        }), writable: true, enumerable: false, configurable: true,


    },
})


WebGLUniformLocation = newFunc('WebGLUniformLocation', 1, function () {
    print('WebGLUniformLocation.call');
    mm.memory.private_data.set(this, {})
});


;delete WebGLUniformLocation.prototype.constructor;
;
Object.defineProperties(WebGLUniformLocation.prototype, {
    [Symbol.toStringTag]: {
        value: 'WebGLUniformLocation'
    },

    'constructor': {

        value: newFunc('constructor', 10, function () {

            if (!WebGLUniformLocation.prototype.isPrototypeOf(this)) {
                throw new TypeError("Illegal constructor");
            }
            ;
            if (debug) print('WebGLUniformLocation.constructor.call', arguments)

        }), writable: true, enumerable: false, configurable: true,


    },
})

WebGLRenderingContext = newFunc('WebGLRenderingContext', 10, function WebGLRenderingContext(key, canvas) {
    mm.memory.private_data.set(this, {
        canvas: canvas,
        context: canvas.context
    })
})
let WebGLDebugRendererInfo = function WebGLDebugRendererInfo(createObj_key) {
    mm.memory.private_data.set(this, {})
};
;(function () {
    const $attributes = {
        UNMASKED_RENDERER_WEBGL: 37446,
        UNMASKED_VENDOR_WEBGL: 37445,
    };

    WebGLDebugRendererInfo.prototype = {};
    for (let key in $attributes) {
        if ($attributes.hasOwnProperty(key)) {
            const value = $attributes[key];
            Object.defineProperty(WebGLDebugRendererInfo, key, {
                value: value,
                configurable: false,
                enumerable: true,
                writable: false
            });
            Object.defineProperty(WebGLDebugRendererInfo.prototype, key, {
                value: value,
                configurable: false,
                enumerable: true,
                writable: false
            });
        }
    }
    ;

    // mm.rename(WebGLDebugRendererInfo.prototype, "WebGLDebugRendererInfo");
    // mm.safeDescriptor_addConstructor(WebGLDebugRendererInfo);

})();


const $safe_get_attribute = ['canvas', 'drawingBufferHeight', 'drawingBufferWidth'];
const $safe_set_attribute = [];
const $safe_func_attribute = [
    'activeTexture', 'attachShader', 'bindAttribLocation', 'bindBuffer', 'bindFramebuffer', 'bindRenderbuffer', 'bindTexture',
    'blendColor', 'blendEquation', 'blendEquationSeparate', 'blendFunc', 'blendFuncSeparate', 'bufferData', 'bufferSubData',
    'checkFramebufferStatus', 'clear', 'clearColor', 'clearDepth', 'clearStencil', 'colorMask', 'compileShader', 'compressedTexImage2D',
    'compressedTexSubImage2D', 'copyTexImage2D', 'copyTexSubImage2D', 'createBuffer', 'createFramebuffer', 'createProgram',
    'createRenderbuffer', 'createShader', 'createTexture', 'cullFace', 'deleteBuffer', 'deleteFramebuffer', 'deleteProgram',
    'deleteRenderbuffer', 'deleteShader', 'deleteTexture', 'depthFunc', 'depthMask', 'depthRange', 'detachShader', 'disable',
    'disableVertexAttribArray', 'drawArrays', 'drawElements', 'enable', 'enableVertexAttribArray', 'finish', 'flush',
    'framebufferRenderbuffer', 'framebufferTexture2D', 'frontFace', 'generateMipmap', 'getActiveAttrib', 'getActiveUniform',
    'getAttachedShaders', 'getAttribLocation', 'getBufferParameter', 'getContextAttributes', 'getError', 'getExtension',
    'getFramebufferAttachmentParameter', 'getParameter', 'getProgramInfoLog', 'getProgramParameter', 'getRenderbufferParameter',
    'getShaderInfoLog', 'getShaderParameter', 'getShaderPrecisionFormat', 'getShaderSource', 'getSupportedExtensions', 'getTexParameter',
    'getUniform', 'getUniformLocation', 'getVertexAttrib', 'getVertexAttribOffset', 'hint', 'isBuffer', 'isContextLost', 'isEnabled',
    'isFramebuffer', 'isProgram', 'isRenderbuffer', 'isShader', 'isTexture', 'lineWidth', 'linkProgram', 'makeXRCompatible',
    'pixelStorei', 'polygonOffset', 'readPixels', 'renderbufferStorage', 'sampleCoverage', 'scissor', 'shaderSource', 'stencilFunc',
    'stencilFuncSeparate', 'stencilMask', 'stencilMaskSeparate', 'stencilOp', 'stencilOpSeparate', 'texImage2D', 'texParameterf',
    'texParameteri', 'texSubImage2D', 'uniform1f', 'uniform1fv', 'uniform1i', 'uniform1iv', 'uniform2f', 'uniform2fv', 'uniform2i',
    'uniform2iv', 'uniform3f', 'uniform3fv', 'uniform3i', 'uniform3iv', 'uniform4f', 'uniform4fv', 'uniform4i', 'uniform4iv',
    'uniformMatrix2fv', 'uniformMatrix3fv', 'uniformMatrix4fv', 'useProgram', 'validateProgram', 'vertexAttrib1f', 'vertexAttrib1fv',
    'vertexAttrib2f', 'vertexAttrib2fv', 'vertexAttrib3f', 'vertexAttrib3fv', 'vertexAttrib4f', 'vertexAttrib4fv', 'vertexAttribPointer',
    'viewport'
];
const $attributes = {
    ACTIVE_ATTRIBUTES: 35721,
    ACTIVE_TEXTURE: 34016,
    ACTIVE_UNIFORMS: 35718,
    ALIASED_LINE_WIDTH_RANGE: 33902,
    ALIASED_POINT_SIZE_RANGE: 33901,
    ALPHA: 6406,
    ALPHA_BITS: 3413,
    ALWAYS: 519,
    ARRAY_BUFFER: 34962,
    ARRAY_BUFFER_BINDING: 34964,
    ATTACHED_SHADERS: 35717,
    BACK: 1029,
    BLEND: 3042,
    BLEND_COLOR: 32773,
    BLEND_DST_ALPHA: 32970,
    BLEND_DST_RGB: 32968,
    BLEND_EQUATION: 32777,
    BLEND_EQUATION_ALPHA: 34877,
    BLEND_EQUATION_RGB: 32777,
    BLEND_SRC_ALPHA: 32971,
    BLEND_SRC_RGB: 32969,
    BLUE_BITS: 3412,
    BOOL: 35670,
    BOOL_VEC2: 35671,
    BOOL_VEC3: 35672,
    BOOL_VEC4: 35673,
    BROWSER_DEFAULT_WEBGL: 37444,
    BUFFER_SIZE: 34660,
    BUFFER_USAGE: 34661,
    BYTE: 5120,
    CCW: 2305,
    CLAMP_TO_EDGE: 33071,
    COLOR_ATTACHMENT0: 36064,
    COLOR_BUFFER_BIT: 16384,
    COLOR_CLEAR_VALUE: 3106,
    COLOR_WRITEMASK: 3107,
    COMPILE_STATUS: 35713,
    COMPRESSED_TEXTURE_FORMATS: 34467,
    CONSTANT_ALPHA: 32771,
    CONSTANT_COLOR: 32769,
    CONTEXT_LOST_WEBGL: 37442,
    CULL_FACE: 2884,
    CULL_FACE_MODE: 2885,
    CURRENT_PROGRAM: 35725,
    CURRENT_VERTEX_ATTRIB: 34342,
    CW: 2304,
    DECR: 7683,
    DECR_WRAP: 34056,
    DELETE_STATUS: 35712,
    DEPTH_ATTACHMENT: 36096,
    DEPTH_BITS: 3414,
    DEPTH_BUFFER_BIT: 256,
    DEPTH_CLEAR_VALUE: 2931,
    DEPTH_COMPONENT: 6402,
    DEPTH_COMPONENT16: 33189,
    DEPTH_FUNC: 2932,
    DEPTH_RANGE: 2928,
    DEPTH_STENCIL: 34041,
    DEPTH_STENCIL_ATTACHMENT: 33306,
    DEPTH_TEST: 2929,
    DEPTH_WRITEMASK: 2930,
    DITHER: 3024,
    DONT_CARE: 4352,
    DST_ALPHA: 772,
    DST_COLOR: 774,
    DYNAMIC_DRAW: 35048,
    ELEMENT_ARRAY_BUFFER: 34963,
    ELEMENT_ARRAY_BUFFER_BINDING: 34965,
    EQUAL: 514,
    FASTEST: 4353,
    FLOAT: 5126,
    FLOAT_MAT2: 35674,
    FLOAT_MAT3: 35675,
    FLOAT_MAT4: 35676,
    FLOAT_VEC2: 35664,
    FLOAT_VEC3: 35665,
    FLOAT_VEC4: 35666,
    FRAGMENT_SHADER: 35632,
    FRAMEBUFFER: 36160,
    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049,
    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048,
    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051,
    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050,
    FRAMEBUFFER_BINDING: 36006,
    FRAMEBUFFER_COMPLETE: 36053,
    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054,
    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057,
    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055,
    FRAMEBUFFER_UNSUPPORTED: 36061,
    FRONT: 1028,
    FRONT_AND_BACK: 1032,
    FRONT_FACE: 2886,
    FUNC_ADD: 32774,
    FUNC_REVERSE_SUBTRACT: 32779,
    MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379,
    MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377,
    MAX_COMBINED_UNIFORM_BLOCKS: 35374,
    FUNC_SUBTRACT: 32778,
    GENERATE_MIPMAP_HINT: 33170,
    GEQUAL: 518,
    GREATER: 516,
    GREEN_BITS: 3411,
    HIGH_FLOAT: 36338,
    HIGH_INT: 36341,
    IMPLEMENTATION_COLOR_READ_FORMAT: 35739,
    IMPLEMENTATION_COLOR_READ_TYPE: 35738,
    INCR: 7682,
    INCR_WRAP: 34055,
    INT: 5124,
    INT_VEC2: 35667,
    INT_VEC3: 35668,
    INT_VEC4: 35669,
    INVALID_ENUM: 1280,
    INVALID_FRAMEBUFFER_OPERATION: 1286,
    INVALID_OPERATION: 1282,
    INVALID_VALUE: 1281,
    INVERT: 5386,
    KEEP: 7680,
    LEQUAL: 515,
    LESS: 513,
    LINEAR: 9729,
    LINEAR_MIPMAP_LINEAR: 9987,
    LINEAR_MIPMAP_NEAREST: 9985,
    LINES: 1,
    LINE_LOOP: 2,
    LINE_STRIP: 3,
    LINE_WIDTH: 2849,
    LINK_STATUS: 35714,
    LOW_FLOAT: 36336,
    LOW_INT: 36339,
    LUMINANCE: 6409,
    LUMINANCE_ALPHA: 6410,
    MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
    MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
    MAX_FRAGMENT_UNIFORM_VECTORS: 36349,
    MAX_RENDERBUFFER_SIZE: 34024,
    MAX_TEXTURE_IMAGE_UNITS: 34930,
    MAX_TEXTURE_SIZE: 3379,
    MAX_VARYING_VECTORS: 36348,
    MAX_VERTEX_ATTRIBS: 34921,
    MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660,
    MAX_VERTEX_UNIFORM_VECTORS: 36347,
    MAX_VIEWPORT_DIMS: 3386,
    MEDIUM_FLOAT: 36337,
    MEDIUM_INT: 36340,
    MIRRORED_REPEAT: 33648,
    NEAREST: 9728,
    NEAREST_MIPMAP_LINEAR: 9986,
    NEAREST_MIPMAP_NEAREST: 9984,
    NEVER: 512,
    NICEST: 4354,
    NONE: 0,
    NOTEQUAL: 517,
    NO_ERROR: 0,
    ONE: 1,
    ONE_MINUS_CONSTANT_ALPHA: 32772,
    ONE_MINUS_CONSTANT_COLOR: 32770,
    ONE_MINUS_DST_ALPHA: 773,
    ONE_MINUS_DST_COLOR: 775,
    ONE_MINUS_SRC_ALPHA: 771,
    ONE_MINUS_SRC_COLOR: 769,
    OUT_OF_MEMORY: 1285,
    PACK_ALIGNMENT: 3333,
    POINTS: 0,
    POLYGON_OFFSET_FACTOR: 32824,
    POLYGON_OFFSET_FILL: 32823,
    POLYGON_OFFSET_UNITS: 10752,
    RED_BITS: 3410,
    RENDERBUFFER: 36161,
    RENDERBUFFER_ALPHA_SIZE: 36179,
    RENDERBUFFER_BINDING: 36007,
    RENDERBUFFER_BLUE_SIZE: 36178,
    RENDERBUFFER_DEPTH_SIZE: 36180,
    RENDERBUFFER_GREEN_SIZE: 36177,
    RENDERBUFFER_HEIGHT: 36163,
    RENDERBUFFER_INTERNAL_FORMAT: 36164,
    RENDERBUFFER_RED_SIZE: 36176,
    RENDERBUFFER_STENCIL_SIZE: 36181,
    RENDERBUFFER_WIDTH: 36162,
    RENDERER: 7937,
    REPEAT: 10497,
    REPLACE: 7681,
    RGB: 6407,
    RGB5_A1: 32855,
    RGB565: 36194,
    RGBA: 6408,
    RGBA4: 32854,
    SAMPLER_2D: 35678,
    SAMPLER_CUBE: 35680,
    SAMPLES: 32937,
    SAMPLE_ALPHA_TO_COVERAGE: 32926,
    SAMPLE_BUFFERS: 32936,
    SAMPLE_COVERAGE: 32928,
    SAMPLE_COVERAGE_INVERT: 32939,
    SAMPLE_COVERAGE_VALUE: 32938,
    SCISSOR_BOX: 3088,
    SCISSOR_TEST: 3089,
    SHADER_TYPE: 35663,
    SHADING_LANGUAGE_VERSION: 35724,
    SHORT: 5122,
    SRC_ALPHA: 770,
    SRC_ALPHA_SATURATE: 776,
    SRC_COLOR: 768,
    STATIC_DRAW: 35044,
    STENCIL_ATTACHMENT: 36128,
    STENCIL_BACK_FAIL: 34817,
    STENCIL_BACK_FUNC: 34816,
    STENCIL_BACK_PASS_DEPTH_FAIL: 34818,
    STENCIL_BACK_PASS_DEPTH_PASS: 34819,
    STENCIL_BACK_REF: 36003,
    STENCIL_BACK_VALUE_MASK: 36004,
    STENCIL_BACK_WRITEMASK: 36005,
    STENCIL_BITS: 3415,
    STENCIL_BUFFER_BIT: 1024,
    STENCIL_CLEAR_VALUE: 2961,
    STENCIL_FAIL: 2964,
    STENCIL_FUNC: 2962,
    STENCIL_INDEX8: 36168,
    STENCIL_PASS_DEPTH_FAIL: 2965,
    STENCIL_PASS_DEPTH_PASS: 2966,
    STENCIL_REF: 2967,
    STENCIL_TEST: 2960,
    STENCIL_VALUE_MASK: 2963,
    STENCIL_WRITEMASK: 2968,
    STREAM_DRAW: 35040,
    SUBPIXEL_BITS: 3408,
    TEXTURE: 5890,
    TEXTURE0: 33984,
    TEXTURE1: 33985,
    TEXTURE2: 33986,
    TEXTURE3: 33987,
    TEXTURE4: 33988,
    TEXTURE5: 33989,
    TEXTURE6: 33990,
    TEXTURE7: 33991,
    TEXTURE8: 33992,
    TEXTURE9: 33993,
    TEXTURE10: 33994,
    TEXTURE11: 33995,
    TEXTURE12: 33996,
    TEXTURE13: 33997,
    TEXTURE14: 33998,
    TEXTURE15: 33999,
    TEXTURE16: 34000,
    TEXTURE17: 34001,
    TEXTURE18: 34002,
    TEXTURE19: 34003,
    TEXTURE20: 34004,
    TEXTURE21: 34005,
    TEXTURE22: 34006,
    TEXTURE23: 34007,
    TEXTURE24: 34008,
    TEXTURE25: 34009,
    TEXTURE26: 34010,
    TEXTURE27: 34011,
    TEXTURE28: 34012,
    TEXTURE29: 34013,
    TEXTURE30: 34014,
    TEXTURE31: 34015,
    TEXTURE_2D: 3553,
    TEXTURE_BINDING_2D: 32873,
    TEXTURE_BINDING_CUBE_MAP: 34068,
    TEXTURE_CUBE_MAP: 34067,
    TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
    TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
    TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
    TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
    TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
    TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
    TEXTURE_MAG_FILTER: 10240,
    TEXTURE_MIN_FILTER: 10241,
    TEXTURE_WRAP_S: 10242,
    TEXTURE_WRAP_T: 10243,
    TRIANGLES: 4,
    TRIANGLE_FAN: 6,
    TRIANGLE_STRIP: 5,
    UNPACK_ALIGNMENT: 3317,
    UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
    UNPACK_FLIP_Y_WEBGL: 37440,
    UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
    UNSIGNED_BYTE: 5121,
    UNSIGNED_INT: 5125,
    UNSIGNED_SHORT: 5123,
    UNSIGNED_SHORT_4_4_4_4: 32819,
    UNSIGNED_SHORT_5_5_5_1: 32820,
    UNSIGNED_SHORT_5_6_5: 33635,
    VALIDATE_STATUS: 35715,
    VENDOR: 7936,
    VERSION: 7938,
    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975,
    VERTEX_ATTRIB_ARRAY_ENABLED: 34338,
    VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922,
    VERTEX_ATTRIB_ARRAY_POINTER: 34373,
    VERTEX_ATTRIB_ARRAY_SIZE: 34339,
    VERTEX_ATTRIB_ARRAY_STRIDE: 34340,
    VERTEX_ATTRIB_ARRAY_TYPE: 34341,
    VERTEX_SHADER: 35633,
    VIEWPORT: 2978,
    MAX_UNIFORM_BUFFER_BINDINGS: 35375,
    ZERO: 0
};

WebGLRenderingContext.prototype = {
    [Symbol.toStringTag]: 'WebGLRenderingContext',
    activeTexture() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'activeTexture', arguments, result);
        return result;
    },
    attachShader() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'attachShader', arguments, result);
        return result;
    },
    bindAttribLocation() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'bindAttribLocation', arguments, result);
        return result;
    },
    bindBuffer(type, webglbuffer) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'bindBuffer', arguments, result);
        return result;
    },
    bindFramebuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'bindFramebuffer', arguments, result);
        return result;
    },
    bindRenderbuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'bindRenderbuffer', arguments, result);
        return result;
    },
    bindTexture() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'bindTexture', arguments, result);
        return result;
    },
    blendColor() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'blendColor', arguments, result);
        return result;
    },
    blendEquation() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'blendEquation', arguments, result);
        return result;
    },
    blendEquationSeparate() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'blendEquationSeparate', arguments, result);
        return result;
    },
    blendFunc() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'blendFunc', arguments, result);
        return result;
    },
    blendFuncSeparate() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'blendFuncSeparate', arguments, result);
        return result;
    },
    bufferData() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        debugger;
        if (debug) print('Func', 'WebGLRenderingContext', 'bufferData', arguments, result);
        return result;
    },
    bufferSubData() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'bufferSubData', arguments, result);
        return result;
    },
    get canvas() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = mm.memory.private_data.get(this).canvas;
        if (debug) print('Get', 'WebGLRenderingContext', 'canvas', arguments, result);
        return result;
    },
    checkFramebufferStatus() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'checkFramebufferStatus', arguments, result);
        return result;
    },
    clear() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'clear', arguments, result);
        return result;
    },
    clearColor() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'clearColor', arguments, result);
        return result;
    },
    clearDepth() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'clearDepth', arguments, result);
        return result;
    },
    clearStencil() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'clearStencil', arguments, result);
        return result;
    },
    colorMask() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'colorMask', arguments, result);
        return result;
    },
    compileShader() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'compileShader', arguments, result);
        return result;
    },
    compressedTexImage2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'compressedTexImage2D', arguments, result);
        return result;
    },
    compressedTexSubImage2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'compressedTexSubImage2D', arguments, result);
        return result;
    },
    copyTexImage2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'copyTexImage2D', arguments, result);
        return result;
    },
    copyTexSubImage2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'copyTexSubImage2D', arguments, result);
        return result;
    },
    createBuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = new WebGLBuffer();
        if (debug) print('Func', 'WebGLRenderingContext', 'createBuffer', arguments, result);
        return result;
    },
    createFramebuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'createFramebuffer', arguments, result);
        return result;
    },
    createProgram() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = new WebGLProgram();
        if (debug) print('Func', 'WebGLRenderingContext', 'createProgram', arguments, result);
        return result;
    },
    createRenderbuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'createRenderbuffer', arguments, result);
        return result;
    },
    createShader(type) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = new WebGLShader();
        if (debug) print('Func', 'WebGLRenderingContext', 'createShader', arguments, result);
        return result;
    },
    createTexture() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'createTexture', arguments, result);
        return result;
    },
    cullFace() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'cullFace', arguments, result);
        return result;
    },
    deleteBuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'deleteBuffer', arguments, result);
        return result;
    },
    deleteFramebuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'deleteFramebuffer', arguments, result);
        return result;
    },
    deleteProgram() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'deleteProgram', arguments, result);
        return result;
    },
    deleteRenderbuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'deleteRenderbuffer', arguments, result);
        return result;
    },
    deleteShader() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'deleteShader', arguments, result);
        return result;
    },
    deleteTexture() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'deleteTexture', arguments, result);
        return result;
    },
    depthFunc() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'depthFunc', arguments, result);
        return result;
    },
    depthMask() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'depthMask', arguments, result);
        return result;
    },
    depthRange() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'depthRange', arguments, result);
        return result;
    },
    detachShader() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'detachShader', arguments, result);
        return result;
    },
    disable() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'disable', arguments, result);
        return result;
    },
    disableVertexAttribArray() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'disableVertexAttribArray', arguments, result);
        return result;
    },
    drawArrays() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'drawArrays', arguments, result);
        return result;
    },
    drawElements() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'drawElements', arguments, result);
        return result;
    },
    get drawingBufferHeight() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = mm.memory.private_data.get(this).canvas.height;
        if (debug) print('Get', 'WebGLRenderingContext', 'drawingBufferHeight', arguments, result);
        return result;
    },
    get drawingBufferWidth() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = mm.memory.private_data.get(this).canvas.width;
        if (debug) print('Get', 'WebGLRenderingContext', 'drawingBufferWidth', arguments, result);
        return result;
    },
    enable() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'enable', arguments, result);
        return result;
    },
    enableVertexAttribArray() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'enableVertexAttribArray', arguments, result);
        return result;
    },
    finish() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'finish', arguments, result);
        return result;
    },
    flush() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'flush', arguments, result);
        return result;
    },
    framebufferRenderbuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'framebufferRenderbuffer', arguments, result);
        return result;
    },
    framebufferTexture2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'framebufferTexture2D', arguments, result);
        return result;
    },
    frontFace() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'frontFace', arguments, result);
        return result;
    },
    generateMipmap() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'generateMipmap', arguments, result);
        return result;
    },
    getActiveAttrib() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getActiveAttrib', arguments, result);
        return result;
    },
    getActiveUniform() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getActiveUniform', arguments, result);
        return result;
    },
    getAttachedShaders() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getAttachedShaders', arguments, result);
        return result;
    },
    getAttribLocation(name) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = 0;

        switch (name) {
            case 'aPosition':
                result = 0;
            case 'aColor':
                result = 1;
        }
        if (debug) print('Func', 'WebGLRenderingContext', 'getAttribLocation', arguments, result);
        return result;
    },
    getBufferParameter() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getBufferParameter', arguments, result);
        return result;
    },
    getContextAttributes() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = {
            alpha: true,
            antialias: true,
            depth: true,
            failIfMajorPerformanceCaveat: false,
            premultipliedAlpha: true,
            preserveDrawingBuffer: false,
            stencil: false
        };
        if (debug) print('Func', 'WebGLRenderingContext', 'getContextAttributes', arguments, result);
        return result;
    },
    getError() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getError', arguments, result);
        return result;
    },
    getExtension(name) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let ele;
        switch (name) {
            case "WEBGL_debug_renderer_info":
                ele = new WebGLDebugRendererInfo(name);
                break;
            case 'EXT_texture_filter_anisotropic':
                ele = new EXTTextureFilterAnisotropic();
                break;
            case 'WEBKIT_EXT_texture_filter_anisotropic':
                ele = new EXTTextureFilterAnisotropic();
                break;
            case 'MOZ_EXT_texture_filter_anisotropic':
                ele = new EXTTextureFilterAnisotropic();
                break;
            default:

        }
        ;

        let result = ele;
        if (debug) print('Func', 'WebGLRenderingContext', 'getExtension ', arguments, result);
        return result;
    },
    getFramebufferAttachmentParameter() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getFramebufferAttachmentParameter', arguments, result);
        return result;
    },
    getParameter(param) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal invocation");
        }
        ;
        let ele = ENV.glres[param + '']

        if (!ele) {
            if (param == 33902) {
                ele = new Float32Array([1, 1])
            }
            if (param === 35377) {
                ele = 53248
            }
            if (param === 35379) {
                ele = 53248;
            }
            if (param === 35374 || param === 35375) {
                ele = 24;
            }
            if (param == 33901) {
                ele = new Float32Array([1, 64])
            }
            if (param == 3386) {
                ele = new Int32Array([16384, 16384])
            }
            if (param === 3415) {
                ele = 0
            }
        }
        let result = ele;
        if (debug) print('Func', 'WebGLRenderingContext', 'getParameter', arguments, '=>>', result);

        return result;
    },
    getProgramInfoLog() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getProgramInfoLog', arguments, result);
        return result;
    },
    getProgramParameter() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = true;
        if (debug) print('Func', 'WebGLRenderingContext', 'getProgramParameter', arguments, result);
        return result;
    },
    getRenderbufferParameter() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getRenderbufferParameter', arguments, result);
        return result;
    },
    getShaderInfoLog() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getShaderInfoLog', arguments, result);
        return result;
    },
    getShaderParameter() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = true;
        if (debug) print('Func', 'WebGLRenderingContext', 'getShaderParameter', arguments, result);
        return result;
    },
    getShaderPrecisionFormat(a, b) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        //todo WebGLShaderPrecisionFormat
//             35633 36338 'res' WebGLShaderPrecisionFormat {rangeMin: range1, rangeMax: range1, precision: range2}precision: range2rangeMax: range1rangeMin: range1[[Prototype]]: WebGLShaderPrecisionFormat
// 35633 36337 'res' WebGLShaderPrecisionFormat {rangeMin: range1, rangeMax: range1, precision: range2}
// 35633 36336 'res' WebGLShaderPrecisionFormat {rangeMin: range1, rangeMax: range1, precision: range2}
// 35632 36338 'res' WebGLShaderPrecisionFormat {rangeMin: range1, rangeMax: range1, precision: range2}
// 35632 36337 'res' WebGLShaderPrecisionFormat {rangeMin: range1, rangeMax: range1, precision: range2}
// 35632 36336
        function randint(a, b) {
            return a + parseInt(Math.random() * (b - a))
        }

        let range1 = 127;
        let range2 = 23
        let range3 = 31
        let range4 = 30
        if (a === 35633 && b === 36338) result = new WebGLShaderPrecisionFormat(range1, range1, range2);
        else if (a === 35633 && b === 36337) result = new WebGLShaderPrecisionFormat(range1, range1, range2);
        else if (a === 35633 && b === 36336) result = new WebGLShaderPrecisionFormat(range1, range1, range2);
        else if (a === 35632 && b === 36338) result = new WebGLShaderPrecisionFormat(range1, range1, range2);
        else if (a === 35632 && b === 36337) result = new WebGLShaderPrecisionFormat(range1, range1, range2);
        else if (a === 35632 && b === 36336) result = new WebGLShaderPrecisionFormat(range1, range1, range2);

//             getShaderPrecisionFormat 35633 36341 res WebGLShaderPrecisionFormat {rangeMin: range3, rangeMax: range4, precision: 0}
// VM377:76 getShaderPrecisionFormat 35633 36340 res WebGLShaderPrecisionFormat {rangeMin: range3, rangeMax: range4, precision: 0}
// VM377:76 getShaderPrecisionFormat 35633 36339 res WebGLShaderPrecisionFormat {rangeMin: range3, rangeMax: range4, precision: 0}
// VM377:76 getShaderPrecisionFormat 35632 36341 res WebGLShaderPrecisionFormat {rangeMin: range3, rangeMax: range4, precision: 0}
// VM377:76 getShaderPrecisionFormat 35632 36340 res WebGLShaderPrecisionFormat {rangeMin: range3, rangeMax: range4, precision: 0}
// VM377:76 getShaderPrecisionFormat 35632 36339 res WebGLShaderPrecisionFormat {rangeMin: range3, rangeMax: range4, precision: 0}
        else if (a === 35633 && b === 36341) result = new WebGLShaderPrecisionFormat(range3, range4, 0);
        else if (a === 35633 && b === 36340) result = new WebGLShaderPrecisionFormat(range3, range4, 0);
        else if (a === 35633 && b === 36339) result = new WebGLShaderPrecisionFormat(range3, range4, 0);
        else if (a === 35632 && b === 36341) result = new WebGLShaderPrecisionFormat(range3, range4, 0);
        else if (a === 35632 && b === 36340) result = new WebGLShaderPrecisionFormat(range3, range4, 0);
        else if (a === 35632 && b === 36339) result = new WebGLShaderPrecisionFormat(range3, range4, 0);

        // let result = {rangeMin: range1, rangeMax: range1, precision: range2};
        if (debug) print('Func', 'WebGLRenderingContext', 'getShaderPrecisionFormat', a, b, a === 35633, b === 36338, result);
        return result;
    },
    getShaderSource() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getShaderSource', arguments, result);
        return result;
    },
    getSupportedExtensions() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        return [
            "ANGLE_instanced_arrays",
            "EXT_blend_minmax",
            "EXT_color_buffer_half_float",
            "EXT_disjoint_timer_query",
            "EXT_float_blend",
            "EXT_frag_depth",
            "EXT_shader_texture_lod",
            "EXT_texture_compression_bptc",
            "EXT_texture_compression_rgtc",
            "EXT_texture_filter_anisotropic",
            "WEBKIT_EXT_texture_filter_anisotropic",
            "EXT_sRGB",
            "KHR_parallel_shader_compile",
            "OES_element_index_uint",
            "OES_fbo_render_mipmap",
            "OES_standard_derivatives",
            "OES_texture_float",
            "OES_texture_float_linear",
            "OES_texture_half_float",
            "OES_texture_half_float_linear",
            "OES_vertex_array_object",
            "WEBGL_color_buffer_float",
            "WEBGL_compressed_texture_s3tc",
            "WEBKIT_WEBGL_compressed_texture_s3tc",
            "WEBGL_compressed_texture_s3tc_srgb",
            "WEBGL_debug_renderer_info",
            "WEBGL_debug_shaders",
            "WEBGL_depth_texture",
            "WEBKIT_WEBGL_depth_texture",
            "WEBGL_draw_buffers",
            "WEBGL_lose_context",
            "WEBKIT_WEBGL_lose_context",
            "WEBGL_multi_draw"
        ]
    },
    getTexParameter() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getTexParameter', arguments, result);
        return result;
    },
    getUniform() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getUniform', arguments, result);
        return result;
    },
    getUniformLocation() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = new WebGLUniformLocation();
        if (debug) print('Func', 'WebGLRenderingContext', 'getUniformLocation', arguments, result);
        return result;
    },
    getVertexAttrib() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getVertexAttrib', arguments, result);
        return result;
    },
    getVertexAttribOffset() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'getVertexAttribOffset', arguments, result);
        return result;
    },
    hint() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'hint', arguments, result);
        return result;
    },
    isBuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isBuffer', arguments, result);
        return result;
    },
    isContextLost() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isContextLost', arguments, result);
        return result;
    },
    isEnabled() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isEnabled', arguments, result);
        return result;
    },
    isFramebuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isFramebuffer', arguments, result);
        return result;
    },
    isProgram() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isProgram', arguments, result);
        return result;
    },
    isRenderbuffer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isRenderbuffer', arguments, result);
        return result;
    },
    isShader() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isShader', arguments, result);
        return result;
    },
    isTexture() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'isTexture', arguments, result);
        return result;
    },
    lineWidth() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'lineWidth', arguments, result);
        return result;
    },
    linkProgram() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'linkProgram', arguments, result);
        return result;
    },
    makeXRCompatible() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'makeXRCompatible', arguments, result);
        return result;
    },
    pixelStorei() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'pixelStorei', arguments, result);
        return result;
    },
    polygonOffset() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'polygonOffset', arguments, result);
        return result;
    },
    readPixels(x, y, width, height, format, type, pixels) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (ENV.webglimg && ENV.webglimg.strs) {
            let r = decompressSTring(ENV.webglimg.strs)
            // pixels.fill(r, 0, r.length)
            for (let i = 0; i < r.length - 1; i++) {
                //todo
                pixels.fill(r[i], i, i + 1)
            }
        }
        if (debug) print('Func', 'WebGLRenderingContext', 'readPixels', arguments, result);
        return result;
    },
    renderbufferStorage() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'renderbufferStorage', arguments, result);
        return result;
    },
    sampleCoverage() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'sampleCoverage', arguments, result);
        return result;
    },
    scissor() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'scissor', arguments, result);
        return result;
    },
    shaderSource(shader, source) {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'shaderSource', arguments, result);
        return result;
    },
    stencilFunc() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'stencilFunc', arguments, result);
        return result;
    },
    stencilFuncSeparate() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'stencilFuncSeparate', arguments, result);
        return result;
    },
    stencilMask() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'stencilMask', arguments, result);
        return result;
    },
    stencilMaskSeparate() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'stencilMaskSeparate', arguments, result);
        return result;
    },
    stencilOp() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'stencilOp', arguments, result);
        return result;
    },
    stencilOpSeparate() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'stencilOpSeparate', arguments, result);
        return result;
    },
    texImage2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'texImage2D', arguments, result);
        return result;
    },
    texParameterf() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'texParameterf', arguments, result);
        return result;
    },
    texParameteri() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'texParameteri', arguments, result);
        return result;
    },
    texSubImage2D() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'texSubImage2D', arguments, result);
        return result;
    },
    uniform1f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform1f', arguments, result);
        return result;
    },
    uniform1fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform1fv', arguments, result);
        return result;
    },
    uniform1i() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform1i', arguments, result);
        return result;
    },
    uniform1iv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform1iv', arguments, result);
        return result;
    },
    uniform2f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform2f', arguments, result);
        return result;
    },
    uniform2fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform2fv', arguments, result);
        return result;
    },
    uniform2i() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform2i', arguments, result);
        return result;
    },
    uniform2iv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform2iv', arguments, result);
        return result;
    },
    uniform3f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform3f', arguments, result);
        return result;
    },
    uniform3fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform3fv', arguments, result);
        return result;
    },
    uniform3i() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform3i', arguments, result);
        return result;
    },
    uniform3iv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform3iv', arguments, result);
        return result;
    },
    uniform4f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform4f', arguments, result);
        return result;
    },
    uniform4fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform4fv', arguments, result);
        return result;
    },
    uniform4i() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform4i', arguments, result);
        return result;
    },
    uniform4iv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniform4iv', arguments, result);
        return result;
    },
    uniformMatrix2fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniformMatrix2fv', arguments, result);
        return result;
    },
    uniformMatrix3fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniformMatrix3fv', arguments, result);
        return result;
    },
    uniformMatrix4fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'uniformMatrix4fv', arguments, result);
        return result;
    },
    useProgram() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'useProgram', arguments, result);
        return result;
    },
    validateProgram() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'validateProgram', arguments, result);
        return result;
    },
    vertexAttrib1f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib1f', arguments, result);
        return result;
    },
    vertexAttrib1fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib1fv', arguments, result);
        return result;
    },
    vertexAttrib2f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib2f', arguments, result);
        return result;
    },
    vertexAttrib2fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib2fv', arguments, result);
        return result;
    },
    vertexAttrib3f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib3f', arguments, result);
        return result;
    },
    vertexAttrib3fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib3fv', arguments, result);
        return result;
    },
    vertexAttrib4f() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib4f', arguments, result);
        return result;
    },
    vertexAttrib4fv() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttrib4fv', arguments, result);
        return result;
    },
    vertexAttribPointer() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'vertexAttribPointer', arguments, result);
        return result;
    },
    viewport() {
        if (!WebGLRenderingContext.prototype.isPrototypeOf(this)) {
            throw new TypeError("Illegal constructor");
        }
        ;
        let result = undefined;
        if (debug) print('Func', 'WebGLRenderingContext', 'viewport', arguments, result);
        return result;
    },
};

for (let key in $attributes) {
    if ($attributes.hasOwnProperty(key)) {
        const value = $attributes[key];
        Object.defineProperty(WebGLRenderingContext, key, {
            value: value,
            configurable: false,
            enumerable: true,
            writable: false
        });
        Object.defineProperty(WebGLRenderingContext.prototype, key, {
            value: value,
            configurable: false,
            enumerable: true,
            writable: false
        });
    }
}
;

// mm.rename(WebGLRenderingContext.prototype, "WebGLRenderingContext");
// mm.safeDescriptor_addConstructor(WebGLRenderingContext);
mm.safe_Objattribute(WebGLRenderingContext, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);



